// Copyright (c) 2005  INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of cgal-python; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with cgal-python.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $Id: Py_Constrained_Delaunay_triangulation_2_doc.h 132 2006-06-29 12:42:38Z nmeskini $
// $URL: svn+ssh://scm.gforge.inria.fr/svn/cgal-python/trunk/cgal-python/bindings/Triangulations_2/Py_Constrained_Delaunay_triangulation_2_doc.h $
//
// Author(s)     : Naceur Meskini
//=========================================================================

#ifndef CONSTRAINED_DELAUNAY_TRIANGULATION_2_DOCS_H
#define CONSTRAINED_DELAUNAY_TRIANGULATION_2_DOCS_H
//=======================================================
//	doc of Constrained_Delaunay_triangulation_2 class
//=======================================================

const char* Constrained_Delaunay_triangulation_2_doc ="\
A constrained Delaunay triangulation is a triangulation with constrained edges which tries\n\
to be as much Delaunay as possible. Constrained edges are not necessarily Delaunay edges, \n\
therefore a constrained Delaunay triangulation is not a Delaunay triangulation. \n\
A constrained Delaunay is a triangulation whose faces do not necessarily fulfill the empty \n\
circle property but fulfill a weaker property called the constrained empty circle. \n\
To state this property, it is convenient to think of constrained edges as blocking the view. \n\
Then, a triangulation is constrained Delaunay if the circumscribing circle of any of its triangular \n\
faces includes in its interior no vertex that is visible from the interior of the triangle.\n\
See a complete C++ documentation:\n\
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Triangulation_2_ref/Class_Constrained_Delaunay_triangulation_2.html";

const char* cdt_init_doc = "\
cdt = Constrained_Delaunay_triangulation_2()\n\
Introduces an empty constrained Delaunay triangulation cdt.";

const char* cdt_is_flipable_doc ="\
cdt.is_flipable(self , Face f, int i) ->bool\n\
Determines if edge (f,i) can be flipped. Returns true if edge (f,i) is not constrained \n\
and the circle circumscribing f contains the vertex of f->neighbor(i) opposite to edge (f,i).";

const char* cdt_flip_doc ="\
cdt.flip(self , Face f, int i) -> void\n\
Flip f and f->neighbor(i).";

const char* cdt_propagating_flip_doc ="\
cdt.propagating_flip(self , edges) -> void\n\
Makes the triangulation constrained Delaunay by flipping edges. \n\
List edges contains an initial list of edges to be flipped. \n\
The returned triangulation is constrained Delaunay if the initial \n\
list contains at least all the edges of the input triangulation that failed \n\
to be constrained Delaunay. (An edge is said to be constrained Delaunay if \n\
it is either constrained or locally Delaunay.)"; 

const char* cdt_insert_doc ="\
cdt.insert(self , Point_2 p, Face f = Face())\n\
Inserts point p in the triangulation. If present f is used as an hint \n\
for the location of p.";
 
const char* cdt_push_back_doc ="\
cdt.push_back(self , Point_2 p) -> Vertex\n\
Equivalent to insert(p)."; 

const char* cdt_remove_doc ="\
cdt.remove(self , Vertex v) -> void\n\
Removes vertex v.\n\
Precondition: Vertex v is not incident to a constrained edge."; 

const char* cdt_remove_incident_constraints_doc ="\
dt.remove_incident_constraints(self , Vertex v) -> void\n\
Make the edges incident to vertex v unconstrained edges.";

const char* cdt_remove_constrained_edge_doc ="\
";

const char* cdt_remove_constraint_doc ="\
cdt.remove_constraint(self , Face f, int i) ->void\n\
Edge(f,i) is no longer constrained. ";

const char* cdt_is_valid_doc ="\
cdt.is_valid(self) -> bool\n\
Checks if the triangulation is valid and if each constrained edge is\n\
consistently marked constrained in its two incident faces."; 

const char* cdt_get_conflicts_doc ="\
cdt.get_conflicts(self , Point_2 p,Face start) ->OutputItFaces\n\
OutItFaces is an iterator of Faces which are in conflict with point p.";

const char* cdt_get_boundary_of_conflicts_doc ="\
get_boundary_of_conflicts(self , Point_2 p,Face start) -> OutputItEdges\n\
This functions outputs the boundary of the zone in conflict with p.\n\
The boundary edges of the conflict zone are ouput in counter-clockwise \n\
order and each edge is described through the incident face which is not\n\
in conflict with p.";

#endif //CONSTRAINED_DELAUNAY_TRIANGULATION_2_DOCS_H
